{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 在 PyTorch 中使用迁移学习进行图像分类\n",
    "\n",
    "参考链接：[https://blog.csdn.net/u013679159/article/details/104256782](https://blog.csdn.net/u013679159/article/details/104256782)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch, torchvision\n",
    "from torchvision import datasets, models, transforms\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import DataLoader\n",
    "import time\n",
    "from torchsummary import summary\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "from PIL import Image\n",
    " \n",
    "# Applying Transforms to the Data\n",
    "image_transforms = { \n",
    "    'train': transforms.Compose([\n",
    "        transforms.RandomResizedCrop(size=256, scale=(0.8, 1.0)),\n",
    "        transforms.RandomRotation(degrees=15),\n",
    "        transforms.RandomHorizontalFlip(),\n",
    "        transforms.CenterCrop(size=224),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize([0.485, 0.456, 0.406],\n",
    "                             [0.229, 0.224, 0.225])\n",
    "    ]),\n",
    "    'valid': transforms.Compose([\n",
    "        transforms.Resize(size=256),\n",
    "        transforms.CenterCrop(size=224),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize([0.485, 0.456, 0.406],\n",
    "                             [0.229, 0.224, 0.225])\n",
    "    ]),\n",
    "    'test': transforms.Compose([\n",
    "        transforms.Resize(size=256),\n",
    "        transforms.CenterCrop(size=224),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize([0.485, 0.456, 0.406],\n",
    "                             [0.229, 0.224, 0.225])\n",
    "    ])\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "{0: 'bear', 1: 'chimp', 2: 'giraffe', 3: 'gorilla', 4: 'llama', 5: 'ostrich', 6: 'porcupine', 7: 'skunk', 8: 'triceratops', 9: 'zebra'}\n"
     ]
    }
   ],
   "source": [
    "dataset = 'transfer_learning'\n",
    " \n",
    "train_directory = os.path.join(dataset, 'train')\n",
    "valid_directory = os.path.join(dataset, 'valid')\n",
    "test_directory = os.path.join(dataset, 'test')\n",
    "\n",
    "bs = 32\n",
    " \n",
    "# Number of classes\n",
    "num_classes = len(os.listdir(valid_directory))  #10\n",
    "print(num_classes)\n",
    " \n",
    "# Load Data from folders\n",
    "data = {\n",
    "    'train': datasets.ImageFolder(root=train_directory, transform=image_transforms['train']),\n",
    "    'valid': datasets.ImageFolder(root=valid_directory, transform=image_transforms['valid']),\n",
    "    'test': datasets.ImageFolder(root=test_directory, transform=image_transforms['test'])\n",
    "}\n",
    " \n",
    "# Get a mapping of the indices to the class names, in order to see the output classes of the test images.\n",
    "idx_to_class = {v: k for k, v in data['train'].class_to_idx.items()}\n",
    "print(idx_to_class)\n",
    " \n",
    "# Size of Data, to be used for calculating Average Loss and Accuracy\n",
    "train_data_size = len(data['train'])\n",
    "valid_data_size = len(data['valid'])\n",
    "test_data_size = len(data['test'])\n",
    " \n",
    "# Create iterators for the Data loaded using DataLoader module\n",
    "train_data_loader = DataLoader(data['train'], batch_size=bs, shuffle=True)\n",
    "valid_data_loader = DataLoader(data['valid'], batch_size=bs, shuffle=True)\n",
    "test_data_loader = DataLoader(data['test'], batch_size=bs, shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load pretrained ResNet50 Model\n",
    "resnet50 = models.resnet50(pretrained=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Freeze model parameters\n",
    "for param in resnet50.parameters():\n",
    "    param.requires_grad = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "fc_inputs = resnet50.fc.in_features\n",
    " \n",
    "resnet50.fc = nn.Sequential(\n",
    "    nn.Linear(fc_inputs, 256),\n",
    "    nn.ReLU(),\n",
    "    nn.Dropout(0.4),\n",
    "    nn.Linear(256, 10), \n",
    "    nn.LogSoftmax(dim=1)\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define Optimizer and Loss Function\n",
    "loss_func = nn.NLLLoss()\n",
    "optimizer = optim.Adam(resnet50.parameters())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1/5\n",
      "Epoch : 000, Training: Loss: 1.6011, Accuracy: 53.0000%, \n",
      "\t\tValidation : Loss : 0.6448, Accuracy: 85.0000%, Time: 108.6954s\n",
      "Epoch: 2/5\n",
      "Epoch : 001, Training: Loss: 0.5503, Accuracy: 87.3333%, \n",
      "\t\tValidation : Loss : 0.3482, Accuracy: 90.0000%, Time: 108.5194s\n",
      "Epoch: 3/5\n",
      "Epoch : 002, Training: Loss: 0.3472, Accuracy: 90.0000%, \n",
      "\t\tValidation : Loss : 0.2079, Accuracy: 95.0000%, Time: 108.4341s\n",
      "Epoch: 4/5\n",
      "Epoch : 003, Training: Loss: 0.2278, Accuracy: 93.8333%, \n",
      "\t\tValidation : Loss : 0.2050, Accuracy: 96.0000%, Time: 108.7869s\n",
      "Epoch: 5/5\n",
      "Epoch : 004, Training: Loss: 0.2579, Accuracy: 90.6667%, \n",
      "\t\tValidation : Loss : 0.2036, Accuracy: 95.0000%, Time: 109.4534s\n"
     ]
    }
   ],
   "source": [
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "def train_and_validate(model, loss_criterion, optimizer, epochs=5):\n",
    "    '''\n",
    "    Function to train and validate\n",
    "    Parameters\n",
    "        :param model: Model to train and validate\n",
    "        :param loss_criterion: Loss Criterion to minimize\n",
    "        :param optimizer: Optimizer for computing gradients\n",
    "        :param epochs: Number of epochs (default=25)\n",
    "  \n",
    "    Returns\n",
    "        model: Trained Model with best validation accuracy\n",
    "        history: (dict object): Having training loss, accuracy and validation loss, accuracy\n",
    "    '''\n",
    "    \n",
    "    start = time.time()\n",
    "    history = []\n",
    "    best_acc = 0.0\n",
    " \n",
    "    for epoch in range(epochs):\n",
    "        epoch_start = time.time()\n",
    "        print(\"Epoch: {}/{}\".format(epoch+1, epochs))\n",
    "        \n",
    "        # Set to training mode\n",
    "        model.train()\n",
    "        \n",
    "        # Loss and Accuracy within the epoch\n",
    "        train_loss = 0.0\n",
    "        train_acc = 0.0\n",
    "        \n",
    "        valid_loss = 0.0\n",
    "        valid_acc = 0.0\n",
    "        \n",
    "        for i, (inputs, labels) in enumerate(train_data_loader):\n",
    " \n",
    "            inputs = inputs.to(device)\n",
    "            labels = labels.to(device)\n",
    "            \n",
    "            # Clean existing gradients\n",
    "            optimizer.zero_grad()\n",
    "            \n",
    "            # Forward pass - compute outputs on input data using the model\n",
    "            outputs = model(inputs)\n",
    "            \n",
    "            # Compute loss\n",
    "            loss = loss_criterion(outputs, labels)\n",
    "            \n",
    "            # Backpropagate the gradients\n",
    "            loss.backward()\n",
    "            \n",
    "            # Update the parameters\n",
    "            optimizer.step()\n",
    "            \n",
    "            # Compute the total loss for the batch and add it to train_loss\n",
    "            train_loss += loss.item() * inputs.size(0)\n",
    "            \n",
    "            # Compute the accuracy\n",
    "            ret, predictions = torch.max(outputs.data, 1)\n",
    "            correct_counts = predictions.eq(labels.data.view_as(predictions))\n",
    "            \n",
    "            # Convert correct_counts to float and then compute the mean\n",
    "            acc = torch.mean(correct_counts.type(torch.FloatTensor))\n",
    "            \n",
    "            # Compute total accuracy in the whole batch and add to train_acc\n",
    "            train_acc += acc.item() * inputs.size(0)\n",
    "            \n",
    "            #print(\"Batch number: {:03d}, Training: Loss: {:.4f}, Accuracy: {:.4f}\".format(i, loss.item(), acc.item()))\n",
    " \n",
    "            \n",
    "        # Validation - No gradient tracking needed\n",
    "        with torch.no_grad():\n",
    " \n",
    "            # Set to evaluation mode\n",
    "            model.eval()\n",
    " \n",
    "            # Validation loop\n",
    "            for j, (inputs, labels) in enumerate(valid_data_loader):\n",
    "                inputs = inputs.to(device)\n",
    "                labels = labels.to(device)\n",
    " \n",
    "                # Forward pass - compute outputs on input data using the model\n",
    "                outputs = model(inputs)\n",
    " \n",
    "                # Compute loss\n",
    "                loss = loss_criterion(outputs, labels)\n",
    " \n",
    "                # Compute the total loss for the batch and add it to valid_loss\n",
    "                valid_loss += loss.item() * inputs.size(0)\n",
    " \n",
    "                # Calculate validation accuracy\n",
    "                ret, predictions = torch.max(outputs.data, 1)\n",
    "                correct_counts = predictions.eq(labels.data.view_as(predictions))\n",
    " \n",
    "                # Convert correct_counts to float and then compute the mean\n",
    "                acc = torch.mean(correct_counts.type(torch.FloatTensor))\n",
    " \n",
    "                # Compute total accuracy in the whole batch and add to valid_acc\n",
    "                valid_acc += acc.item() * inputs.size(0)\n",
    " \n",
    "                #print(\"Validation Batch number: {:03d}, Validation: Loss: {:.4f}, Accuracy: {:.4f}\".format(j, loss.item(), acc.item()))\n",
    "            \n",
    "        # Find average training loss and training accuracy\n",
    "        avg_train_loss = train_loss/train_data_size \n",
    "        avg_train_acc = train_acc/train_data_size\n",
    " \n",
    "        # Find average training loss and training accuracy\n",
    "        avg_valid_loss = valid_loss/valid_data_size \n",
    "        avg_valid_acc = valid_acc/valid_data_size\n",
    " \n",
    "        history.append([avg_train_loss, avg_valid_loss, avg_train_acc, avg_valid_acc])\n",
    "                \n",
    "        epoch_end = time.time()\n",
    "    \n",
    "        print(\"Epoch : {:03d}, Training: Loss: {:.4f}, Accuracy: {:.4f}%, \\n\\t\\tValidation : Loss : {:.4f}, Accuracy: {:.4f}%, Time: {:.4f}s\".format(epoch, avg_train_loss, avg_train_acc*100, avg_valid_loss, avg_valid_acc*100, epoch_end-epoch_start))\n",
    "        \n",
    "        # Save if the model has best accuracy till now\n",
    "        torch.save(model, dataset+'_model_'+str(epoch)+'.pt')\n",
    "            \n",
    "    return model, history\n",
    "# Print the model to be trained\n",
    "# summary(resnet50, input_size=(3, 224, 224), batch_size=bs, device='cuda')\n",
    " \n",
    "# Train the model for 30 epochs\n",
    "num_epochs = 5\n",
    "trained_model, history = train_and_validate(resnet50, loss_func, optimizer, num_epochs)\n",
    " \n",
    "torch.save(history, dataset+'_history.pt')\n",
    "\n",
    "import os\n",
    "os.environ[\"KMP_DUPLICATE_LIB_OK\"]  =  \"TRUE\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "history = np.array(history)\n",
    "plt.plot(history[:,0:2])\n",
    "plt.legend(['Tr Loss', 'Val Loss'])\n",
    "plt.xlabel('Epoch Number')\n",
    "plt.ylabel('Loss')\n",
    "plt.ylim(0,1)\n",
    "plt.savefig(dataset+'_loss_curve.png')\n",
    "plt.show()\n",
    "plt.plot(history[:,2:4])\n",
    "plt.legend(['Tr Accuracy', 'Val Accuracy'])\n",
    "plt.xlabel('Epoch Number')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.ylim(0,1)\n",
    "plt.savefig(dataset+'_accuracy_curve.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def computeTestSetAccuracy(model, loss_criterion):\n",
    "    '''\n",
    "    Function to compute the accuracy on the test set\n",
    "    Parameters\n",
    "        :param model: Model to test\n",
    "        :param loss_criterion: Loss Criterion to minimize\n",
    "    '''\n",
    " \n",
    "    device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    " \n",
    "    test_acc = 0.0\n",
    "    test_loss = 0.0\n",
    " \n",
    "    # Validation - No gradient tracking needed\n",
    "    with torch.no_grad():\n",
    " \n",
    "        # Set to evaluation mode\n",
    "        model.eval()\n",
    " \n",
    "        # Validation loop\n",
    "        for j, (inputs, labels) in enumerate(test_data_loader):\n",
    "            inputs = inputs.to(device)\n",
    "            labels = labels.to(device)\n",
    " \n",
    "            # Forward pass - compute outputs on input data using the model\n",
    "            outputs = model(inputs)\n",
    " \n",
    "            # Compute loss\n",
    "            loss = loss_criterion(outputs, labels)\n",
    " \n",
    "            # Compute the total loss for the batch and add it to valid_loss\n",
    "            test_loss += loss.item() * inputs.size(0)\n",
    " \n",
    "            # Calculate validation accuracy\n",
    "            ret, predictions = torch.max(outputs.data, 1)\n",
    "            correct_counts = predictions.eq(labels.data.view_as(predictions))\n",
    " \n",
    "            # Convert correct_counts to float and then compute the mean\n",
    "            acc = torch.mean(correct_counts.type(torch.FloatTensor))\n",
    " \n",
    "            # Compute total accuracy in the whole batch and add to valid_acc\n",
    "            test_acc += acc.item() * inputs.size(0)\n",
    " \n",
    "            print(\"Test Batch number: {:03d}, Test: Loss: {:.4f}, Accuracy: {:.4f}\".format(j, loss.item(), acc.item()))\n",
    " \n",
    "    # Find average test loss and test accuracy\n",
    "    avg_test_loss = test_loss/test_data_size \n",
    "    avg_test_acc = test_acc/test_data_size\n",
    " \n",
    "    print(\"Test accuracy : \" + str(avg_test_acc))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Batch number: 000, Test: Loss: 0.0653, Accuracy: 1.0000\n",
      "Test Batch number: 001, Test: Loss: 0.1620, Accuracy: 0.9375\n",
      "Test Batch number: 002, Test: Loss: 0.2663, Accuracy: 0.9062\n",
      "Test Batch number: 003, Test: Loss: 0.2500, Accuracy: 0.9062\n",
      "Test Batch number: 004, Test: Loss: 0.1540, Accuracy: 0.9375\n",
      "Test Batch number: 005, Test: Loss: 0.1214, Accuracy: 0.9375\n",
      "Test Batch number: 006, Test: Loss: 0.1310, Accuracy: 0.9688\n",
      "Test Batch number: 007, Test: Loss: 0.1159, Accuracy: 0.9688\n",
      "Test Batch number: 008, Test: Loss: 0.1231, Accuracy: 0.9688\n",
      "Test Batch number: 009, Test: Loss: 0.0585, Accuracy: 1.0000\n",
      "Test Batch number: 010, Test: Loss: 0.1900, Accuracy: 0.9688\n",
      "Test Batch number: 011, Test: Loss: 0.1729, Accuracy: 0.9375\n",
      "Test Batch number: 012, Test: Loss: 0.1961, Accuracy: 0.8800\n",
      "Test accuracy : 0.9486552564322511\n"
     ]
    }
   ],
   "source": [
    "model = torch.load('transfer_learning_model_8.pt')\n",
    "computeTestSetAccuracy(model, loss_func)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cost time 0.17444562911987305\n",
      "Predcition 1 : zebra , Score:  0.9996805\n",
      "Predcition 2 : triceratops , Score:  0.00013148312\n",
      "Predcition 3 : chimp , Score:  5.1325533e-05\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def predict(model, test_image_name):\n",
    "    '''\n",
    "    Function to predict the class of a single test image\n",
    "    Parameters\n",
    "        :param model: Model to test\n",
    "        :param test_image_name: Test image\n",
    "    '''\n",
    "    \n",
    "    transform = image_transforms['test']\n",
    " \n",
    "    test_image = Image.open(test_image_name)\n",
    "    plt.imshow(test_image)\n",
    "    \n",
    "    test_image_tensor = transform(test_image)\n",
    " \n",
    "    if torch.cuda.is_available():\n",
    "        test_image_tensor = test_image_tensor.view(1, 3, 224, 224).cuda()\n",
    "    else:\n",
    "        test_image_tensor = test_image_tensor.view(1, 3, 224, 224)\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        model.eval()\n",
    "        # Model outputs log probabilities\n",
    "        start = time.time()\n",
    "        out = model(test_image_tensor)\n",
    "        stop = time.time()\n",
    "        print('cost time', stop-start)\n",
    "        ps = torch.exp(out)\n",
    "        topk, topclass = ps.topk(3, dim=1)\n",
    "        for i in range(3):\n",
    "            print(\"Predcition\", i+1, \":\", idx_to_class[topclass.cpu().numpy()[0][i]], \", Score: \", topk.cpu().numpy()[0][i])\n",
    "model = torch.load('transfer_learning_model_8.pt')\n",
    "predict(model, 'transfer_learning/test/zebra/250_0091.jpg')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
